tree_entry.go:104

• TreeEntry.Size uses sync.Once and silently returns 0 on any error. If the first call fails (e.g. context deadline exceeded), the 0 value is cached forever and subsequent calls cannot retry with a fresh context, which can produce incorrect sizes and downstream behavior (e.g. Blob.Bytes preallocation). Consider switching to the same pattern used by Tree.Entries/Commit.Submodules (mutex + sizeSet flag) so only successful lookups are cached, or otherwise avoid caching failed attempts.
  command.go:143
• When log output is enabled (logOutput != nil), RunInDirWithOptions wraps opt.Stdout in limitDualWriter but still writes to the underlying writer (w.w) unconditionally. If the caller passes a nil Stdout (valid for exec.Cmd), this will panic once the command writes output. Consider defaulting a nil Stdout to io.Discard (both for cmd.Stdout and the wrapped writer) when logging is enabled.

	buf := new(bytes.Buffer)
	w := opt.Stdout
	if logOutput != nil {
		buf.Grow(512)
		w = &limitDualWriter{
			W: buf,
			N: int64(buf.Cap()),
			w: opt.Stdout,
		}

tree_entry.go:103

• TreeEntry.Size uses sync.Once, so if the first call fails (e.g., context deadline exceeded / transient git error), e.size remains 0 and the failure is effectively cached forever. Consider switching to a mutex + sizeSet flag (like Tree.Entries / BinVersion) so the size is only cached after a successful cat-file -s + parse, and callers can retry with a fresh context.

tree_entry.go:106

• The Size() method uses sync.Once for caching but takes a context.Context parameter. This creates an inconsistency: the context is only used on the first invocation (inside sizeOnce.Do), and subsequent calls ignore the provided context and return the cached value.

This differs from the pattern used elsewhere in this PR (e.g., Tree.Entries, Commit.Submodules, BinVersion) where failed attempts are not cached, allowing retries with a fresh context. If the first Size() call fails due to context cancellation or timeout, the error is silently ignored (line 100-101 just returns), and subsequent calls will return 0.

Consider either:

1. Changing to the mutex+flag pattern used elsewhere so failed attempts can be retried, or
2. Documenting this behavior clearly in the method comment

tree_entry.go:107

• The Size() method still uses sync.Once for caching, which is inconsistent with the new caching pattern used elsewhere in this PR. Other similar methods (Tree.Entries(), Commit.Submodules(), BinVersion()) now use a mutex+flag pattern that doesn't cache failures, allowing retries with a fresh context.

Consider refactoring TreeEntry.Size() to use the same mutex+flag pattern:

• Change sizeOnce sync.Once to sizeMu sync.Mutex and sizeSet bool
• Lock/unlock the mutex and check sizeSet flag
• Only set sizeSet = true on successful execution
• This would allow retries if the git command fails (e.g., due to context timeout)